/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"
#include "预设材质.h"

#include <缓存.h>

#include "物体/物体.h"
#include "物体/S_摄像机.h"
#include "core/引擎配置.h"
#include "MBT_Engine.h"





bool	S_单色点材质::m_是否以创建着色器 = false;
bool	S_单色面材质::m_是否以创建着色器 = false;
bool	S_单色线框材质::m_是否以创建着色器 = false;
bool	S_单色描边材质::m_是否以创建着色器 = false;
bool	S_单色平直面材质::m_是否以创建着色器 = false;
bool	S_单色线段材质::m_是否以创建着色器 = false;
bool	S_单色连续线材质::m_是否以创建着色器 = false;
bool	S_单色虚线材质::m_是否以创建着色器 = false;
bool	S_图标材质::m_是否以创建着色器 = false;


bool	S_基本光照描边材质::m_是否以创建着色器 = false;

bool		S_基本光照点材质::m_是否以创建着色器 = false;
S_结构对象* S_基本光照点材质::g_参数布局 = nullptr;
S_管线组引用 S_基本光照点材质::g管线引用 = {};


bool	S_面基本光照材质::m_是否以创建着色器 = false;
bool	S_线基本光照材质::m_是否以创建着色器 = false;

bool	S_权重可视材质::m_是否以创建着色器 = false;
bool	S_索引绘制_基本颜色材质::m_是否以创建着色器 = false;

bool	S_线逐顶点有色材质::m_是否以创建着色器 = false;
bool	S_线逐顶点有色线段材质::m_是否以创建着色器 = false;
bool	S_线逐顶点有色连续线材质::m_是否以创建着色器 = false;
bool	S_扇形线逐顶点有色材质::m_是否以创建着色器 = false;
bool	S_单色逐顶点线描边材质::m_是否以创建着色器 = false;

bool	S_数值标注材质::m_是否以创建着色器 = false;


bool	S_物理光照光追材质::m_是否以创建着色器 = false;
bool	S_包围盒材质::m_是否以创建着色器 = false;
bool	S_AABB材质::m_是否以创建着色器 = false;

bool			S_PBR材质::m_是否以创建着色器 = false;
S_结构对象*		S_PBR材质::g_参数布局 = nullptr;
S_管线组引用	S_PBR材质::g管线引用 = {};


bool			S_天空材质::m_是否以创建着色器 = false;
S_结构对象*		S_天空材质::g_参数布局 = nullptr;
S_管线组引用	S_天空材质::g管线引用 = {};

bool	S_PBR阴影材质::m_是否以创建着色器 = false;


bool			S_PBR线段材质::m_是否以创建着色器 = false;
S_结构对象*		S_PBR线段材质::g_参数布局 = nullptr;
S_管线组引用	S_PBR线段材质::g管线引用 = {};

bool	 		S_线段材质::g_是否以创建着色器 = false;
S_结构对象*		S_线段材质::g_参数布局 = nullptr;
S_管线组引用	S_线段材质::g_管线引用 = {};



//static S_板载缓存* g_骨骼默认缓存_骨骼属性 = nullptr;
static S_板载缓存* g_骨骼默认缓存_骨骼变换 = nullptr;
static S_板载缓存* g_骨骼默认缓存_顶点权重 = nullptr;
static S_板载缓存* g_骨骼默认缓存_顶点骨骼 = nullptr;
static S_板载缓存* g_骨骼默认缓存_选中骨骼ID = nullptr;
static S_板载缓存* g_基本光照材质缓存_灯光方向 = nullptr;

static S_GPU内存块 g_顶点骨骼属性;
static S_GPU内存块 g_骨骼权重映射;
static S_GPU内存块 g_骨骼姿态;


//std::atomic_int32_t S_数值标注材质::m_着色器引用数量 = 0;





static void f_updateGPU单色参数布局(S_材质管线* mat, S_GPU参数布局& layout, uint16 网格属性缓存槽数量) {
	S_单色面材质* sm = (S_单色面材质*)(mat);

	uint16 num = 网格属性缓存槽数量 + 1;
	if (num != layout.m_绑定数量) f_alloc缓存槽(&layout, num);

	layout.m_参数槽[网格属性缓存槽数量 + 0] = sm->m_Color;
}






static void f_创建骨骼GPU默认参数(S_设备环境& ctx) {
	
	if (!g_骨骼默认缓存_骨骼变换) g_骨骼默认缓存_骨骼变换 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, sizeof(Mat44f));
	if (!g_骨骼默认缓存_顶点权重) g_骨骼默认缓存_顶点权重 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, sizeof(S_BoneMap));
	if (!g_骨骼默认缓存_顶点骨骼) g_骨骼默认缓存_顶点骨骼 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, sizeof(S_VertBone));
	if(!g_骨骼默认缓存_选中骨骼ID) g_骨骼默认缓存_选中骨骼ID = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, sizeof(uint32));
	if (!g_基本光照材质缓存_灯光方向) {
		g_基本光照材质缓存_灯光方向 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_UBO, sizeof(vec4));
		f_buf_fill板载缓存<vec4>(g_基本光照材质缓存_灯光方向, { {0,1,0,1}, {0,1,0,1}, {0,1,0,1}, {0,1,0,1} }, E_板载缓存类型::e_UBO);
	}


	g_顶点骨骼属性 = f_bm_alloc(f_buf_getGlobal().g_骨骼属性, 0);
	g_骨骼权重映射 = f_bm_alloc(f_buf_getGlobal().g_骨骼权重, 0);
	g_骨骼姿态 = f_bm_alloc(S_物体::g_骨骼姿态, 0);
}












static S_着色器创建配置 f_单色图元配置() {
	S_着色器创建配置 图元配置;

	图元配置 = {
		{
			{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_WIDGET_Color, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_LineProp, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
		},
		{
			{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
		},
		{
			{S_引擎配置::m_3D着色器文件根路径 + "单色_顶点阶段.spv", {}, E_着色阶段::e_顶点着色},
			{S_引擎配置::m_3D着色器文件根路径 + "单色_片源阶段.spv", {}, E_着色阶段::e_像素着色},
		},
		{
			{E_着色阶段::e_顶点着色, 0, sizeof(S_Vert_MeshDrawProp)},
		}

	};

	return 图元配置;
}
static S_着色器创建配置 f_单色平直着色图元配置() {
	S_着色器创建配置 图元配置;

	图元配置 = {
		{
			{0, E_着色阶段::e_几何着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},
			{2, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},
			{3, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},
			{4, E_着色阶段::e_几何着色, E_板载缓存类型::e_UBO},
		},
		{
			{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
		},
		{
			{S_引擎配置::m_3D着色器文件根路径 + "单色明暗着色_顶点阶段.spv", {}, E_着色阶段::e_顶点着色},
			{S_引擎配置::m_3D着色器文件根路径 + "单色明暗着色_几何阶段.spv", {}, E_着色阶段::e_几何着色},
			{S_引擎配置::m_3D着色器文件根路径 + "单色明暗着色_片源阶段.spv", {}, E_着色阶段::e_像素着色},
		},
		{
			{E_着色阶段::e_顶点着色, 0, sizeof(S_Vert_MeshDrawProp)},
		}
	};

	return 图元配置;
}

S_单色材质::S_单色材质(S_设备环境& ctx, bool 独立缩放) : S_材质管线(&ctx) {
	m_Color = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_UBO);
	f_buf_fill板载缓存<uint32>(m_Color, { 0xffffffff }, E_板载缓存类型::e_UBO);

	//if (独立缩放) {
	//	m_材质属性 = f_buf_create板载缓存(ctx, sizeof(S_单色材质属性), E_板载缓存类型::e_UBO);
	//	f_buf_fill板载缓存<S_单色材质属性>(m_材质属性, { {0, 1, 0, 0} }, E_板载缓存类型::e_UBO);
	//
	//	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU独立缩放单色着色参数配置;
	//}
	//else {
	//	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU单色着色参数配置;
	//}
}

S_单色材质::~S_单色材质() {

}
void S_单色材质::f_set颜色(S_RGBA8UI color) {
	m_Color->f_map();
	*((uint32*)(m_Color->m_mappedPtr)) = f_PackData4X8(color);
	m_Color->f_unmap();
}

S_材质管线* S_单色材质::f_copy(S_单色材质* mat) {
	mat->m_着色线管->m_Pipeline = m_着色线管->m_Pipeline;
	mat->m_着色线管->m_Shader = m_着色线管->m_Shader;
	mat->m_着色线管->m_GPU参数set = m_着色线管->m_GPU参数set;

	mat->m_深度遮挡 = m_深度遮挡;
	mat->m_Color = m_Color;
	mat->m_材质属性 = m_材质属性;
	
	mat->mf_GPU参数配置 = mf_GPU参数配置;
	return mat;
}







S_单色点材质::S_单色点材质(S_设备环境& ctx) : S_单色材质(ctx, false) {

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_画点集;
		线管参数.m_填充模式 = E_填充模式::e_填充点;
		线管参数.m_采样 = ctx.m_采样数;

		auto 图元配置 = f_单色图元配置();
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = true;
	}
	//mf_GPU材质槽更新 = f_updateGPU单色参数布局;
}

S_材质管线* S_单色点材质::f_copy() {
	S_单色点材质* mat = new S_单色点材质(*m_Ctx);
	S_单色材质::f_copy(mat);
	return mat;
}


S_单色线框材质::S_单色线框材质(S_设备环境& ctx) : S_单色材质(ctx, false) {

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_三角形;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;

		auto 图元配置 = f_单色图元配置();
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = true;
	}
}

S_材质管线* S_单色线框材质::f_copy() {
	S_单色线框材质* mat = new S_单色线框材质(*m_Ctx);
	S_单色材质::f_copy(mat);
	return mat;
}


S_单色面材质::S_单色面材质(S_设备环境& ctx) : S_单色材质(ctx, false) {

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_三角形;
		线管参数.m_填充模式 = E_填充模式::e_填充面;
		线管参数.m_采样 = ctx.m_采样数;

		auto 图元配置 = f_单色图元配置();
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = true;
	}
}

S_材质管线* S_单色面材质::f_copy() {
	S_单色点材质* mat = new S_单色点材质(*m_Ctx);
	S_单色材质::f_copy(mat);
	return mat;
}


S_单色平直面材质::S_单色平直面材质(S_设备环境& ctx) : S_单色材质(ctx, false) {
	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_三角形;
		线管参数.m_填充模式 = E_填充模式::e_填充面;
		线管参数.m_采样 = ctx.m_采样数;
		//线管参数.m_启用混合 = false;
		//线管参数.m_透明混合模式 = E_混合模式::e_最大;
		//线管参数.m_颜色混合模式 = E_混合模式::e_最大;
		//线管参数.m_目标颜色混合因子 = E_混合因子::e_源一减源透明通道;

		auto 图元配置 = f_单色图元配置();
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = true;
	}
}

S_材质管线* S_单色平直面材质::f_copy() {
	S_单色平直面材质* mat = new S_单色平直面材质(*m_Ctx);
	S_单色材质::f_copy(mat);
	return mat;
}



S_单色描边材质::S_单色描边材质(S_设备环境& ctx) : S_单色材质(ctx, false) {
	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_三角形;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;
		//线管参数.m_启用写入深度 = false;
		//线管参数.m_启用深度边界 = true;
		//线管参数.m_启用深度测试 = false;
		//线管参数.m_颜色混合模式 = E_混合模式::e_最小;
		//线管参数.m_透明混合模式 = E_混合模式::e_最大;
		//线管参数.m_目标颜色混合因子 = E_混合因子::e_混合因子零;

		auto 图元配置 = f_单色图元配置();
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = true;
	}
}

S_材质管线* S_单色描边材质::f_copy() {
	S_单色描边材质* mat = new S_单色描边材质(*m_Ctx);
	S_单色材质::f_copy(mat);
	return mat;
}






S_单色线段材质::S_单色线段材质(S_设备环境& ctx) : S_单色材质(ctx, false) {
	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_画线段;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;

		auto 图元配置 = f_单色图元配置();
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = true;
	}

	f_buf_fill板载缓存<uint32>(m_Color, { f_PackData4X8({200, 200, 200, 255}) }, E_板载缓存类型::e_UBO);
}

S_材质管线* S_单色线段材质::f_copy() {
	S_单色线段材质* mat = new S_单色线段材质(*m_Ctx);
	S_单色材质::f_copy(mat);
	return mat;
}





S_单色连续线材质::S_单色连续线材质(S_设备环境& ctx) : S_单色材质(ctx, false) {
	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_画连续线;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;

		auto 图元配置 = f_单色图元配置();
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = true;
	}
}

S_材质管线* S_单色连续线材质::f_copy() {
	S_单色连续线材质* mat = new S_单色连续线材质(*m_Ctx);
	S_单色材质::f_copy(mat);
	return mat;
}





S_独立缩放单色材质::S_独立缩放单色材质(S_设备环境& ctx, E_绘制方式 绘制方式, E_填充模式 填充模式, bool 写入深度, bool 深度测试, bool 独立缩放)
	: S_单色材质(ctx, 独立缩放), 线管参数({ 1024, 1024 }), m_独立缩放(独立缩放), m_是否以创建着色器(false)
{
	if (!m_是否以创建着色器) {
		线管参数.m_绘制方式 = 绘制方式;
		线管参数.m_填充模式 = 填充模式;
		
		线管参数.m_采样 = ctx.m_采样数;
		线管参数.m_启用深度测试 = 深度测试;
		线管参数.m_启用写入深度 = 写入深度;

		S_着色器创建配置 图元配置;
		if (m_独立缩放) {
			图元配置 = f_单色平直着色图元配置();
		} else {
			图元配置 = f_单色图元配置();
		}
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = true;
	}
}

S_材质管线* S_独立缩放单色材质::f_copy() {
	S_独立缩放单色材质* mat = new S_独立缩放单色材质(*m_Ctx, 线管参数.m_绘制方式, 线管参数.m_填充模式, 线管参数.m_启用写入深度, 线管参数.m_启用深度测试, m_独立缩放);
	S_单色材质::f_copy(mat);
	return mat;
}






S_单色虚线材质::S_单色虚线材质(S_设备环境& ctx, bool 是否连续) : S_材质管线(&ctx), m_线管参数({512,512}), m_是否连续(是否连续) {
	if (!m_是否以创建着色器) {
		if (是否连续) {
			m_线管参数.m_绘制方式 = E_绘制方式::e_画连续线;
		}
		else {
			m_线管参数.m_绘制方式 = E_绘制方式::e_画线段;
		}
		
		m_线管参数.m_填充模式 = E_填充模式::e_填充线;
		m_线管参数.m_启用写入深度 = true;
		m_线管参数.m_采样 = ctx.m_采样数;


		S_着色器创建配置 图元配置;
		if (m_独立缩放) {
			图元配置 = f_单色平直着色图元配置();
		}
		else {
			图元配置 = f_单色图元配置();
		}
		f_df_创建材质着色器(ctx, this, 图元配置, m_线管参数);

		m_是否以创建着色器 = true;
	}
}

S_材质管线* S_单色虚线材质::f_copy() {
	S_单色虚线材质* mat = new S_单色虚线材质(*m_Ctx, m_是否连续);
	mat->m_着色线管->m_Pipeline = m_着色线管->m_Pipeline;
	mat->m_着色线管->m_Shader = m_着色线管->m_Shader;
	mat->m_着色线管->m_GPU参数set = m_着色线管->m_GPU参数set;

	mat->m_深度遮挡 = m_深度遮挡;
	mat->mf_GPU参数配置 = mf_GPU参数配置;

	return mat;
}






static void f_updateGPU线逐顶点有色参数布局(S_材质管线* mat, S_物体* ob, S_Mesh* mesh, uint8 元素, uint32 多维子元素) {
	S_线逐顶点有色材质* sm = (S_线逐顶点有色材质*)(mat);

	f_df_allocGPU参数缓存槽(&mesh->m_多维材质槽[多维子元素].m_参数槽, 3);
	
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[2] = &mesh->m_网格元素变换属性;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[2] = DEF_BINDING_LineProp;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[2] = E_板载缓存类型::e_SSBO;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[2] = 1;
}

//static void f_updateGPU线逐顶点有色线段参数布局(S_材质* mat, S_物体* ob, S_Mesh* mesh, uint8 元素, uint32 多维子元素) {
//	S_线逐顶点有色线段材质* sm = (S_线逐顶点有色线段材质*)(mat);
//	f_allocGPU参数缓存槽(&mesh->m_多维材质槽[多维子元素].m_参数槽, 3);
//	//if (mesh->m_GPU参数布局.m_绑定数量 != 3) {
//	//	f_alloc缓存槽(&mesh->m_GPU参数布局, 3);
//	//
//	//	mesh->m_GPU参数布局.m_绑定位置[0] = 0;
//	//	mesh->m_GPU参数布局.m_绑定位置[1] = 1;
//	//}
//	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[2] = &mesh->m_网格元素变换属性;
//	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[2] = DEF_BINDING_LineProp;
//	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[2] = E_板载缓存类型::e_SSBO;
//	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[2] = 1;
//}

//static void f_updateGPU线逐顶点有色线参数布局(S_材质* mat, S_物体* ob, S_Mesh* mesh) {
//	S_线逐顶点有色线段材质* sm = (S_线逐顶点有色线段材质*)(mat);
//	if (mesh->m_GPU参数布局.m_绑定数量 != 3) {
//		f_alloc缓存槽(&mesh->m_GPU参数布局, 3);
//
//		mesh->m_GPU参数布局.m_绑定位置[0] = 0;
//		mesh->m_GPU参数布局.m_绑定位置[1] = 1;
//	}
//	mesh->m_GPU参数布局.m_参数槽[2] = mesh->m_网格元素变换属性.m_Buf;
//	mesh->m_GPU参数布局.m_绑定位置[2] = DEF_BINDING_LineProp;
//}

S_线逐顶点有色材质::S_线逐顶点有色材质(S_设备环境& ctx, bool 是否有深度遮挡, E_绘制方式 绘制方式) {
	//m_绘制参数 = f_buf_create板载缓存(ctx, sizeof(S_MeshTranformProp), E_板载缓存类型::e_SSBO);
	
	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = 绘制方式;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;

		线管参数.m_启用写入深度 = 是否有深度遮挡;


		S_着色器创建配置 图元配置 = {
			{
				{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
				{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				{DEF_BINDING_LineProp, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(uint32),0,E_数据格式::e_UI_R32},
			},
			{
				{S_引擎配置::m_3D着色器文件根路径 + "逐顶点有色_顶点阶段.spv", {}, E_着色阶段::e_顶点着色},
				{S_引擎配置::m_3D着色器文件根路径 + "逐顶点有色_片源阶段.spv", {}, E_着色阶段::e_像素着色},
			},
			{
				{E_着色阶段::e_顶点着色, 0, sizeof(S_Vert_MeshDrawProp)},
			}
		};
		
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
		m_是否以创建着色器 = false;
	}
	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU线逐顶点有色参数布局;
}

//void S_线逐顶点有色材质::f_set材质参数(float32 绘制距离, uint32 实例ID) {
	//f_buf_fill板载缓存<float32>(m_绘制参数, { 100.0f }, E_板载缓存类型::e_UBO);
//}




S_线逐顶点有色线段材质::S_线逐顶点有色线段材质(S_设备环境& ctx, bool 是否有深度遮挡, E_绘制方式 绘制方式, E_填充模式 填充模式) {
	//m_绘制参数 = f_buf_create板载缓存(ctx, sizeof(S_MeshTranformProp), E_板载缓存类型::e_SSBO);
	//f_buf_fill板载缓存<S_MeshTranformProp>(m_绘制参数, { f_init_MeshTranform() }, E_板载缓存类型::e_SSBO);

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		
		线管参数.m_绘制方式 = 绘制方式;
		//线管参数.m_填充模式 = 填充模式;
		线管参数.m_采样 = ctx.m_采样数;

		线管参数.m_启用深度测试 = 是否有深度遮挡;
		线管参数.m_启用写入深度 = 是否有深度遮挡;

		S_着色器创建配置 图元配置 = {
			{
				{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
				{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				{DEF_BINDING_LineProp, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			},
			{ }, { },
			{
				{E_着色阶段::e_顶点着色, 0, sizeof(S_Vert_MeshDrawProp)},
			}
		};
		
		switch (填充模式) {
			case E_填充模式::e_填曲线: {
				线管参数.m_填充模式 = E_填充模式::e_填充线;
				图元配置.m_顶点配置 = {
					{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
					{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
					{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
					{0,sizeof(uvec3),0,E_数据格式::e_UI_R32G32B32},
				};
				图元配置.m_Paths = {
					{S_引擎配置::m_3D着色器文件根路径 + "空间曲线.vspv", {}, E_着色阶段::e_顶点着色},
					{ S_引擎配置::m_3D着色器文件根路径 + "空间曲线.gspv", {}, E_着色阶段::e_几何着色 },
					{ S_引擎配置::m_3D着色器文件根路径 + "空间曲线.fspv", {}, E_着色阶段::e_像素着色 },
				};
				break;
			}
			case E_填充模式::e_填曲线控制点: {
				线管参数.m_填充模式 = E_填充模式::e_填充线;
				图元配置.m_顶点配置 = {
					{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
					{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
					{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
					{0,sizeof(uvec3),0,E_数据格式::e_UI_R32G32B32},
				};
				图元配置.m_Paths = {
					{S_引擎配置::m_3D着色器文件根路径 + "空间曲线.vspv", {}, E_着色阶段::e_顶点着色},
					{ S_引擎配置::m_3D着色器文件根路径 + "空间曲线控制点.gspv", {}, E_着色阶段::e_几何着色 },
					{ S_引擎配置::m_3D着色器文件根路径 + "空间曲线控制点.fspv", {}, E_着色阶段::e_像素着色 },
				};
				break;
			}
			case E_填充模式::e_填曲线控制线: {
				线管参数.m_填充模式 = E_填充模式::e_填充线;
				图元配置.m_顶点配置 = {
					{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
					{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
					{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
					{0,sizeof(uvec3),0,E_数据格式::e_UI_R32G32B32},
				};
				图元配置.m_Paths = {
					{S_引擎配置::m_3D着色器文件根路径 + "空间曲线.vspv", {}, E_着色阶段::e_顶点着色},
					{ S_引擎配置::m_3D着色器文件根路径 + "空间曲线控制线.gspv", {}, E_着色阶段::e_几何着色 },
					{ S_引擎配置::m_3D着色器文件根路径 + "空间曲线.fspv", {}, E_着色阶段::e_像素着色 },
				};
				break;
			}
			default:
				//图元配置.m_参数布局 = {
				//	{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
				//	{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				//	{DEF_BINDING_LineProp, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				//};
				图元配置.m_顶点配置 = {
					{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
					{0,sizeof(uint32),0,E_数据格式::e_UI_R32},
				};
				图元配置.m_Paths = {
					{S_引擎配置::m_3D着色器文件根路径 + "逐顶点有色_顶点阶段.spv", {}, E_着色阶段::e_顶点着色},
					{S_引擎配置::m_3D着色器文件根路径 + "逐顶点有色_片源阶段.spv", {}, E_着色阶段::e_像素着色},
				};
				break;
		}

		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
		m_是否以创建着色器 = false;
	}

	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU线逐顶点有色参数布局;
}

void S_线逐顶点有色线段材质::f_set材质参数(float32 绘制距离, uint32 实例ID) {
	//f_buf_fill板载缓存<float32>(m_绘制参数, { 100.0f }, E_板载缓存类型::e_UBO);
}




S_扇形线逐顶点有色材质::S_扇形线逐顶点有色材质(S_设备环境& ctx, bool 是否有深度遮挡) {
	m_绘制参数 = f_buf_create板载缓存(ctx, sizeof(S_MeshTranformProp), E_板载缓存类型::e_SSBO);
	f_buf_fill板载缓存<S_MeshTranformProp>(m_绘制参数, { f_init_MeshTranform() }, E_板载缓存类型::e_SSBO);

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_画扇形;
		线管参数.m_填充模式 = E_填充模式::e_填充面;
		线管参数.m_采样 = ctx.m_采样数;

		线管参数.m_启用深度测试 = 是否有深度遮挡;
		线管参数.m_启用写入深度 = 是否有深度遮挡;

		S_着色器创建配置 图元配置 = {
			{
				{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
				{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				{DEF_BINDING_LineProp, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(uint32),0,E_数据格式::e_UI_R32},
			},
			{
				{S_引擎配置::m_3D着色器文件根路径 + "逐顶点有色_顶点阶段.spv", {}, E_着色阶段::e_顶点着色},
				{S_引擎配置::m_3D着色器文件根路径 + "逐顶点有色_片源阶段.spv", {}, E_着色阶段::e_像素着色},
			}
		};

		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
		m_是否以创建着色器 = false;
	}

	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU线逐顶点有色参数布局;
}

void S_扇形线逐顶点有色材质::f_set材质参数(float32 绘制距离, uint32 实例ID) {
	f_buf_fill板载缓存<float32>(m_绘制参数, { 100.0f }, E_板载缓存类型::e_UBO);
}




S_线逐顶点有色连续线材质::S_线逐顶点有色连续线材质(S_设备环境& ctx, bool 是否有深度遮挡) {
	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_画连续线;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;

		线管参数.m_启用深度测试 = 是否有深度遮挡;
		线管参数.m_启用写入深度 = 是否有深度遮挡;

		S_着色器创建配置 图元配置 = {
			{
				{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
				{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				{DEF_BINDING_LineProp, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(uint32),0,E_数据格式::e_UI_R32},
			},
			{
				{S_引擎配置::m_3D着色器文件根路径 + "逐顶点有色_顶点阶段.spv", {}, E_着色阶段::e_顶点着色},
			    {S_引擎配置::m_3D着色器文件根路径 + "逐顶点有色_片源阶段.spv", {}, E_着色阶段::e_像素着色},
			},
			{
				{E_着色阶段::e_顶点着色, 0, sizeof(S_Vert_MeshDrawProp)},
			}
		};

		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
		m_是否以创建着色器 = false;
	}

	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU线逐顶点有色参数布局;
}

S_线逐顶点有色连续线材质::~S_线逐顶点有色连续线材质() {
}

//void S_线逐顶点有色连续线材质::f_set材质参数(float32 绘制距离, uint32 实例ID) {
	//f_buf_fill板载缓存<float32>(m_绘制参数, { 100.0f }, E_板载缓存类型::e_UBO);
//}




 




static S_着色器创建配置 f_基本光照图元配置(E_基本光照片源类型 描边类型) {
	S_着色器创建配置 图元配置;

	std::vector<S_着色器加载参数> m_Paths;
	//std::vector<S_着色器常量推送创建参数> m_常量偏移和字节数;


	图元配置 = {
		{
			{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{2, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},		//灯光方向
			{DEF_BINDING_WIDGET_Color, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},

			{DEF_BINDING_Bones_Props, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_Bones_Map, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_Bones_Matrix, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			//{DEF_BINDING_Bones_Weigth, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},

			{DEF_BINDING_LineProp, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_ObMesh,  E_着色阶段::e_几何着色 | E_着色阶段::e_像素着色, E_板载缓存类型::e_SSBO},
		},
		{
			{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
			{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
			{0,sizeof(vec2),0,E_数据格式::e_F_R32G32},
		},

			m_Paths,

		{
			{ E_着色阶段::e_顶点着色, 0, sizeof(S_Vert_MeshDrawProp) },
		}
	};

	

	switch (描边类型) {
		case E_基本光照片源类型::e_描边:
			图元配置.m_Paths.push_back({ S_引擎配置::m_3D着色器文件根路径 + "基本光照_顶点阶段.spv", {}, E_着色阶段::e_顶点着色 });
			图元配置.m_Paths.push_back({ S_引擎配置::m_3D着色器文件根路径 + "基本光照线段.fspv", {}, E_着色阶段::e_像素着色 });
			break;

		case E_基本光照片源类型::e_描边2:
			图元配置.m_Paths.push_back({ S_引擎配置::m_3D着色器文件根路径 + "基本光照_顶点阶段.spv", {}, E_着色阶段::e_顶点着色 });
			图元配置.m_Paths.push_back({ S_引擎配置::m_3D着色器文件根路径 + "基本光照轮廓_几何阶段.spv", {}, E_着色阶段::e_几何着色 });
			图元配置.m_Paths.push_back({ S_引擎配置::m_3D着色器文件根路径 + "基本光照描边.fspv", {}, E_着色阶段::e_像素着色 });

			图元配置.m_参数布局.push_back({ DEF_BINDING_Face_AdjacencyID_BindID, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO });
			图元配置.m_参数布局.push_back({ DEF_BINDING_Face_Normal_BindID, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO });
			图元配置.m_参数布局.push_back({ DEF_BINDING_Face_Center_BindID, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO });

			break;

		case E_基本光照片源类型::e_平直明暗:
			图元配置.m_Paths.push_back({ S_引擎配置::m_3D着色器文件根路径 + "基本光照_顶点阶段.spv", {}, E_着色阶段::e_顶点着色 });
			图元配置.m_Paths.push_back({ S_引擎配置::m_3D着色器文件根路径 + "基本平直光照_几何阶段.spv", {}, E_着色阶段::e_几何着色 });
			图元配置.m_Paths.push_back({ S_引擎配置::m_3D着色器文件根路径 + "基本光照_片源阶段.spv", {}, E_着色阶段::e_像素着色 });
			break;

		case E_基本光照片源类型::e_权重:
			图元配置.m_Paths.push_back({ S_引擎配置::m_3D着色器文件根路径 + "基本光照_顶点阶段.spv", {}, E_着色阶段::e_顶点着色 });
			图元配置.m_Paths.push_back({ S_引擎配置::m_3D着色器文件根路径 + "权重_片源阶段.spv", {}, E_着色阶段::e_像素着色 });
			break;

		case E_基本光照片源类型::e_颜色:
			图元配置.m_Paths.push_back({ S_引擎配置::m_3D着色器文件根路径 + "基本光照_顶点阶段.spv", {}, E_着色阶段::e_顶点着色 });
			图元配置.m_Paths.push_back({ S_引擎配置::m_3D着色器文件根路径 + "索引绘制_基本颜色_片源阶段.spv", {}, E_着色阶段::e_像素着色 });
			break;

		case E_基本光照片源类型::e_ICO纹理:
			图元配置.m_Paths.push_back({ S_引擎配置::m_3D着色器文件根路径 + "图标_顶点阶段.spv", {}, E_着色阶段::e_顶点着色 });
			图元配置.m_Paths.push_back({ S_引擎配置::m_3D着色器文件根路径 + "图标_片源阶段.spv", {}, E_着色阶段::e_像素着色 });
			break;

		default:
			图元配置.m_Paths.push_back({ S_引擎配置::m_3D着色器文件根路径 + "基本光照_顶点阶段.spv", {}, E_着色阶段::e_顶点着色 });
			图元配置.m_Paths.push_back({ S_引擎配置::m_3D着色器文件根路径 + "基本光照_片源阶段.spv", {}, E_着色阶段::e_像素着色 });
			break;
	}
	
	return 图元配置;
}

void f_update着色器_骨骼配置(S_物体* ob, S_Mesh* mesh, uint32 多维子元素, uint32 offset) {
	//if (纹理槽数量) f_alloc缓存槽(&layout, 纹理槽数量);
	if (ob->m_骨架) {
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[offset] = mesh->m_顶点骨骼属性;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[offset] = DEF_BINDING_Bones_Props;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[offset] = E_板载缓存类型::e_SSBO;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[offset] = 1;

		++offset;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[offset] = mesh->m_骨骼权重映射;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[offset] = DEF_BINDING_Bones_Map;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[offset] = E_板载缓存类型::e_SSBO;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[offset] = 1;

		++offset;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[offset] = &ob->m_骨架->m_姿态;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[offset] = DEF_BINDING_Bones_Matrix;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[offset] = E_板载缓存类型::e_SSBO;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[offset] = 1;
	}
	else {
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[offset] = &g_顶点骨骼属性;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[offset] = DEF_BINDING_Bones_Props;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[offset] = E_板载缓存类型::e_SSBO;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[offset] = 1;

		++offset;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[offset] = &g_骨骼权重映射;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[offset] = DEF_BINDING_Bones_Map;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[offset] = E_板载缓存类型::e_SSBO;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[offset] = 1;

		++offset;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[offset] = &g_骨骼姿态;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[offset] = DEF_BINDING_Bones_Matrix;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[offset] = E_板载缓存类型::e_SSBO;
		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[offset] = 1;
	}
}

static void f_updateGPU基本光照参数配置(S_材质管线* mat, S_物体* ob, S_Mesh* me, uint8 元素, uint32 多维子元素) {
	f_df_allocGPU参数缓存槽(&me->m_多维材质槽[多维子元素].m_参数槽, 9);

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[2] = g_基本光照材质缓存_灯光方向;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[2] = 2;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[2] = E_板载缓存类型::e_UBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[2] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[3] = &ob->m_实例颜色[元素];
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[3] = DEF_BINDING_WIDGET_Color;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[3] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[3] = 1;

	f_update着色器_骨骼配置(ob, me, 多维子元素, 4);

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[7] = &me->m_网格元素变换属性;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[7] = DEF_BINDING_LineProp;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[7] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[7] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[8] = me->m_网格属性;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[8] = DEF_BINDING_ObMesh;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[8] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[8] = 1;
	//me->m_多维材质槽[多维子元素].m_参数槽.m_纹理槽 = &S_全局缓存::g_全局模型纹理槽;
}


static void f_updateGPU基本光照参数配置_描边(S_材质管线* mat, S_物体* ob, S_Mesh* mesh, uint8 元素, uint32 多维子元素) {
	//S_面基本光照材质* sm = (S_面基本光照材质*)(mat);
	f_df_allocGPU参数缓存槽(&mesh->m_多维材质槽[多维子元素].m_参数槽, 12);

	//if (mesh->m_GPU参数布局.m_绑定数量 != 12) {
	//	f_alloc缓存槽(&mesh->m_GPU参数布局, 12);
	//
	//	mesh->m_GPU参数布局.m_参数槽[2] = g_基本光照材质缓存_灯光方向;
	//	mesh->m_GPU参数布局.m_绑定位置[2] = 2;
	//}
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[2] = g_基本光照材质缓存_灯光方向;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[2] = 2;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[2] = E_板载缓存类型::e_UBO;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[2] = 1;

	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[3] = &ob->m_实例颜色[元素];
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[3] = DEF_BINDING_WIDGET_Color;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[3] = E_板载缓存类型::e_SSBO;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[3] = 1;

	f_update着色器_骨骼配置(ob, mesh, 多维子元素, 4);

	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[7] = &mesh->m_网格元素变换属性;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[7] = DEF_BINDING_LineProp;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[7] = E_板载缓存类型::e_SSBO;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[7] = 1;

	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[8] = mesh->m_网格属性;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[8] = DEF_BINDING_ObMesh;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[8] = E_板载缓存类型::e_SSBO;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[8] = 1;

	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[9] = mesh->m_邻接面索引;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[9] = DEF_BINDING_Face_AdjacencyID_BindID;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[9] = E_板载缓存类型::e_SSBO;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[9] = 1;

	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[10] = mesh->m_面法线;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[10] = DEF_BINDING_Face_Normal_BindID;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[10] = E_板载缓存类型::e_SSBO;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[10] = 1;

	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[11] = mesh->m_面中心;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[11] = DEF_BINDING_Face_Center_BindID;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[11] = E_板载缓存类型::e_SSBO;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[11] = 1;
}


S_基本光照描边材质::S_基本光照描边材质(S_设备环境& ctx, E_绘制方式 绘制方式) {
	bool 新描边方式 = 绘制方式 == E_绘制方式::e_画邻接三角形;

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_三角形;
		线管参数.m_填充模式 = E_填充模式::e_填充面;
		线管参数.m_采样 = ctx.m_采样数;
		//线管参数.m_深度偏移 = 0.1;
		//线管参数.m_填充模式 = E_填充模式::e_填充面;
		线管参数.m_启用写入深度 = true;
		//线管参数.m_启用深度边界 = true;
		
		auto 图元配置	= f_基本光照图元配置(新描边方式 ? E_基本光照片源类型::e_描边2 : E_基本光照片源类型::e_描边);
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = false;
		f_创建骨骼GPU默认参数(ctx);
	}
	if (新描边方式) {
		mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU基本光照参数配置_描边;
	}
	else {
		mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU基本光照参数配置;
	}
}

static void f_update基本光照点材质参数配置(S_材质管线* mat, S_物体* ob, S_Mesh* me, uint8 元素, uint32 多维子元素) {
	f_df_allocGPU参数缓存槽(&me->m_多维材质槽[多维子元素].m_参数槽, 3);

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[1] = &ob->m_实例颜色[元素];
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[1] = DEF_BINDING_WIDGET_Color;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[1] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[1] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[2] = &me->m_网格元素变换属性;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[2] = DEF_BINDING_LineProp;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[2] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[2] = 1;

	//me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[4] = me->m_网格属性;
	//me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[4] = DEF_BINDING_ObMesh;
	//me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[4] = E_板载缓存类型::e_SSBO;
	//me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[4] = 1;
	me->m_多维材质槽[多维子元素].m_参数槽.m_纹理槽;

	me->m_多维材质槽[多维子元素].m_参数槽.m_GPU布局描述 = S_基本光照点材质::g_参数布局;
}

S_基本光照点材质::S_基本光照点材质(S_设备环境& ctx, bool 平滑着色) {
	m_Ctx = &ctx;
	m_独立统一缓存 = true;

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });

		线管参数.m_填充模式 = E_填充模式::e_填充点;
		线管参数.m_绘制方式 = E_绘制方式::e_画点集;
		线管参数.m_采样 = ctx.m_采样数;


		S_着色器创建配置 图元配置 = {
			{
				//{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
				//{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				//{DEF_BINDING_WIDGET_Color, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				//{DEF_BINDING_LineProp, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(uvec2),0,E_数据格式::e_UI_R32G32},
			},

			{
				{ S_引擎配置::m_3D着色器文件根路径 + "基本光照点.vspv", {}, E_着色阶段::e_顶点着色 },
				{ S_引擎配置::m_3D着色器文件根路径 + "基本光照点.gspv", {}, E_着色阶段::e_几何着色 },
				{ S_引擎配置::m_3D着色器文件根路径 + "基本光照点.fspv", {}, E_着色阶段::e_像素着色 },
			},

			{
				{ E_着色阶段::e_顶点着色, 0, sizeof(S_Vert_MeshDrawProp) },
			}
		};

		std::vector<S_着色器创建参数> 参数布局 = {
			{1,							E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_WIDGET_Color,	E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_LineProp,		E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
		};

		//g_参数布局 = f_df_创建着色器参数布局(ctx, 参数布局, nullptr);
		//S_结构对象* layout[3] = { S_Engine::g_摄像机GPU布局描述, g_参数布局 };


		//线管参数.m_槽 = E_管线槽::e_颜色渲染;
		//g管线引用.m_着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 2);
		//
		//线管参数.m_槽 = E_管线槽::e_环境渲染;
		//g管线引用.m_环境着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 2);
		//
		//线管参数.m_槽 = E_管线槽::e_阴影渲染;
		//g管线引用.m_阴影着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 2);
		//
		//线管参数.m_槽 = E_管线槽::e_几何渲染;
		//g管线引用.m_几何着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 2);

		m_是否以创建着色器 = false;
	}
	else {
		f_pl_引用管线(this, g管线引用);
	}

	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_update基本光照点材质参数配置;
	
}

S_基本光照点材质::~S_基本光照点材质() {
	f_df_销毁绑定参数布局(*m_Ctx, g_参数布局);
}




S_面基本光照材质::S_面基本光照材质(S_设备环境& ctx, bool 平滑着色) {
	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		
		线管参数.m_填充模式 = E_填充模式::e_填充面;
		线管参数.m_绘制方式 = E_绘制方式::e_三角形;
		线管参数.m_采样 = ctx.m_采样数;
		

		S_着色器创建配置 图元配置 = f_基本光照图元配置(平滑着色 ? E_基本光照片源类型::e_明暗 : E_基本光照片源类型::e_平直明暗);
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = false;
		f_创建骨骼GPU默认参数(ctx);
	}
	
	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU基本光照参数配置;
	++S_全局缓存::m_着色器引用数量;
}

S_面基本光照材质::~S_面基本光照材质() {
	--S_全局缓存::m_着色器引用数量;

	if (S_全局缓存::m_着色器引用数量 <= 0) {
		f_df_销毁材质着色器(this);
	}
}

S_线基本光照材质::S_线基本光照材质(S_设备环境& ctx, E_绘制方式 绘制方式) {
	
	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = 绘制方式;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;

		S_着色器创建配置 图元配置 = f_基本光照图元配置(绘制方式 == E_绘制方式::e_画线段 ? E_基本光照片源类型::e_描边 : E_基本光照片源类型::e_明暗);
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = false;
		f_创建骨骼GPU默认参数(ctx);
	}
	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU基本光照参数配置;
}

S_权重可视材质::S_权重可视材质(S_设备环境& ctx, E_填充模式 填充模式) {
	m_Color = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_UBO);
	f_buf_fill板载缓存<uint32>(m_Color, { f_PackData4X8({25, 25, 28, 255}) }, E_板载缓存类型::e_UBO);

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_三角形;
		线管参数.m_填充模式 = 填充模式;
		线管参数.m_采样 = ctx.m_采样数;


		S_着色器创建配置 图元配置 = f_基本光照图元配置(E_基本光照片源类型::e_权重);
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = false;
		f_创建骨骼GPU默认参数(ctx);
	}
	//mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU权重可视参数配置;
	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU基本光照参数配置;
}

S_权重可视材质::~S_权重可视材质() {
	f_buf_release板载缓存(m_Color);
}



S_索引绘制_基本颜色材质::S_索引绘制_基本颜色材质(S_设备环境& ctx, E_绘制方式 绘制方式, E_填充模式 填充模式) {
	
	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = 绘制方式;
		线管参数.m_填充模式 = 填充模式;
		线管参数.m_采样 = ctx.m_采样数;

		switch (绘制方式) {
			case E_绘制方式::e_画邻接线段:
			case E_绘制方式::e_画线段:
			case E_绘制方式::e_画点集:
				线管参数.m_图元重启 = false;
				break;
			default:
				线管参数.m_图元重启 = true;
				break;
		}

		S_着色器创建配置 图元配置 = f_基本光照图元配置(E_基本光照片源类型::e_颜色);
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = false;
		f_创建骨骼GPU默认参数(ctx);
	}
	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU基本光照参数配置;
}






static void f_updateGPU参数配置_图标(S_材质管线* mat, S_物体* ob, S_Mesh* mesh, uint8 元素, uint32 多维子元素) {
	S_图标材质* sm = (S_图标材质*)(mat);
	f_df_allocGPU参数缓存槽(&mesh->m_多维材质槽[多维子元素].m_参数槽, 7);

	//if (mesh->m_GPU参数布局.m_绑定数量 != 7) {
	//	f_alloc缓存槽(&mesh->m_GPU参数布局, 7);
	//	f_alloc纹理槽(&mesh->m_GPU参数布局, 1);
	//
	//	mesh->m_GPU参数布局.m_参数槽[2] = mesh->m_网格元素变换属性.m_Buf;
	//	mesh->m_GPU参数布局.m_绑定位置[2] = DEF_BINDING_LineProp;
	//
	//}

	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[2] = &mesh->m_网格元素变换属性;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[2] = DEF_BINDING_LineProp;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[2] = E_板载缓存类型::e_SSBO;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[2] = 1;

	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[3] = &ob->m_实例颜色[元素];
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[3] = DEF_BINDING_WIDGET_Color;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[3] = E_板载缓存类型::e_SSBO;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[3] = 1;

	f_update着色器_骨骼配置(ob, mesh, 多维子元素, 4);

	mesh->m_多维材质槽[多维子元素].m_参数槽.m_纹理槽 = &sm->纹理槽;
	
	//mesh->m_多维材质槽[多维子元素].m_参数槽.m_纹理槽[0] = sm->m_图标纹理;
	//mesh->m_多维材质槽[多维子元素].m_参数槽.m_纹理绑定位置[0] = DEF_BINDING_LineProp;

	//mesh->m_GPU参数布局.m_参数槽[7] = mesh->m_网格元素属性.m_Buf;
	//mesh->m_GPU参数布局.m_绑定位置[7] = DEF_BINDING_LineProp;
	//mesh->m_GPU参数布局.m_参数槽[8] = sm->m_图标纹理->m_Tex;
	//mesh->m_GPU参数布局.m_绑定位置[8] = DEF_BINDING_WIDGET_Texture;
}

S_图标材质::S_图标材质(S_设备环境& ctx) {
	//m_图标纹理 = S_Engine::g_默认图标->m_Tex;
	纹理槽 = f_纹理槽_创建(1);
	f_纹理槽_设置纹理(纹理槽, S_全局缓存::g_默认图标->m_Tex, DEF_BINDING_WIDGET_Texture, 0);


	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_画点集;
		线管参数.m_填充模式 = E_填充模式::e_填充点;
		线管参数.m_图元重启 = false;
		线管参数.m_采样 = ctx.m_采样数;


		S_着色器创建配置 图元配置;
		std::vector<S_着色器加载参数> m_Paths;
		图元配置 = {
			{
				{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
				{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				
				{DEF_BINDING_WIDGET_Color, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				{DEF_BINDING_LineProp, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},

				{DEF_BINDING_Bones_Props, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				{DEF_BINDING_Bones_Map, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				{DEF_BINDING_Bones_Matrix, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				//{DEF_BINDING_Bones_Weigth, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				

				{DEF_BINDING_WIDGET_Texture, E_着色阶段::e_像素着色, E_板载缓存类型::e_SAMPLER_Array},		//灯光方向
			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(vec2),0,E_数据格式::e_F_R32G32},
			},

				m_Paths,

			{
				{ E_着色阶段::e_顶点着色, 0, sizeof(S_Vert_MeshDrawProp) },
			}
		};

		图元配置.m_Paths.push_back({ S_引擎配置::m_3D着色器文件根路径 + "图标_顶点阶段.spv", {}, E_着色阶段::e_顶点着色 });
		图元配置.m_Paths.push_back({ S_引擎配置::m_3D着色器文件根路径 + "图标_片源阶段.spv", {}, E_着色阶段::e_像素着色 });


		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = false;
		f_创建骨骼GPU默认参数(ctx);
	}
	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU参数配置_图标;
}







static void f_updateGPU_FLIP可视预览材质参数布局(S_材质管线* mat, S_物体* ob, S_Mesh* mesh, uint8 元素, uint32 多维子元素) {
	//S_FLIP可视预览材质* sm = (S_FLIP可视预览材质*)(mat);
	f_df_allocGPU参数缓存槽(&mesh->m_多维材质槽[多维子元素].m_参数槽, 4);

	//if (mesh->m_GPU参数布局.m_绑定数量 != 4) {
	//	f_alloc缓存槽(&mesh->m_GPU参数布局, 4);
	//
	//	mesh->m_GPU参数布局.m_参数槽[2] = g_基本光照材质缓存_灯光方向;
	//	mesh->m_GPU参数布局.m_绑定位置[2] = 2;
	//
	//}
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[2] = g_基本光照材质缓存_灯光方向;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[2] = 2;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[2] = E_板载缓存类型::e_UBO;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[2] = 1;

	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[3] = &ob->m_实例颜色[元素];
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[3] = DEF_BINDING_WIDGET_Color;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[3] = E_板载缓存类型::e_SSBO;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[3] = 1;
}

S_FLIP可视预览材质::S_FLIP可视预览材质(S_设备环境& ctx) {
	
	S_着色器创建配置 图元配置 = {
		{
			{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{2, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
			{DEF_BINDING_WIDGET_Color, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
		},
		{
			{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
			{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
			{0,sizeof(vec2),0,E_数据格式::e_F_R32G32},
		},
		{
			{S_引擎配置::m_3D着色器文件根路径 + "FLIP可视预览_顶点阶段.spv", {}, E_着色阶段::e_顶点着色},
			{S_引擎配置::m_3D着色器文件根路径 + "FLIP可视预览_片源阶段.spv", {}, E_着色阶段::e_像素着色},
		},
		{
			{ E_着色阶段::e_顶点着色, 0, sizeof(S_Vert_MeshDrawProp) },
		}
	};

	S_线管创建参数 线管参数({ 1024, 1024 });
	线管参数.m_绘制方式 = E_绘制方式::e_画点集;
	线管参数.m_填充模式 = E_填充模式::e_填充点;
	线管参数.m_采样 = ctx.m_采样数;
	f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU_FLIP可视预览材质参数布局;
}










//static void f_updateGPU_PBF可视预览材质参数布局(S_材质* mat, S_GPU参数布局& layout, uint16 网格属性缓存槽数量) {
//	S_PBF可视预览材质* sm = (S_PBF可视预览材质*)(mat);
//	uint16 num = 网格属性缓存槽数量 + 1;
//	if (num != layout.m_绑定数量) f_alloc缓存槽(&layout, num);
//	layout.m_参数槽[网格属性缓存槽数量 + 0] = sm->m_GPU参数;
//}
//
//S_PBF可视预览材质::S_PBF可视预览材质(S_设备环境& ctx) {
//	m_GPU参数 = f_buf_create板载缓存(ctx, sizeof(S_DomProp), E_板载缓存类型::e_UBO);
//	vec4 dim = {0.2, 0.2, 1.0, 1.0};
//	f_buf_fill板载缓存<vec4>(m_GPU参数, &dim, 1, E_板载缓存类型::e_UBO);
//
//	S_线管创建配置 图元配置 = {
//		{
//			{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
//			{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
//			{2, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
//		},
//		{
//			{0, sizeof(vec4), 0, E_数据格式::e_F_RGBA},
//		},
//		{
//			{S_引擎配置::m_3D着色器文件根路径 + "PBF可视预览_顶点阶段.spv", {}, E_着色阶段::e_顶点着色},
//			{S_引擎配置::m_3D着色器文件根路径 + "FLIP可视预览_片源阶段.spv", {}, E_着色阶段::e_像素着色},
//		}
//	};
//
//	S_线管创建参数 线管参数({ 1024, 1024 });
//	线管参数.m_绘制方式 = E_绘制方式::e_画点集;
//	线管参数.m_填充模式 = E_填充模式::e_填充面;
//	线管参数.m_采样 = ctx.m_采样数;
//	f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
//
//	mf_GPU材质槽更新 = f_updateGPU_PBF可视预览材质参数布局;
//}
//
//void S_PBF可视预览材质::f_set颜色(vec4 color, uint32 实例ID) {
//	f_buf_fill板载缓存<vec4>(m_GPU参数, &color, 1, E_板载缓存类型::e_UBO);
//}









static void f_updateGPU_体素可视网格预览材质参数布局(S_材质管线* mat, S_GPU参数布局& layout, uint16 网格属性缓存槽数量) {
	S_八叉树可视预览材质* sm = (S_八叉树可视预览材质*)(mat);

	uint16 num = 网格属性缓存槽数量 + 2;
	if (num != layout.m_绑定数量) f_alloc缓存槽(&layout, num);

	layout.m_参数槽[网格属性缓存槽数量 + 0] = sm->m_GPU参数;
	layout.m_参数槽[网格属性缓存槽数量 + 1] = sm->m_颜色;
}

//S_体素可视网格预览材质::S_体素可视网格预览材质(S_设备环境& ctx) {
//	m_GPU参数 = f_buf_create板载缓存(ctx, sizeof(S_DomProp), E_板载缓存类型::e_UBO);
//	m_颜色 = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_UBO);
//
//	S_域绘制属性 dim = { {64,64,64, 1}, {10,10,10, 0.2f}, {0,0,0,0} };
//	f_buf_fill板载缓存<S_域绘制属性>(m_GPU参数, &dim, 1, E_板载缓存类型::e_UBO);
//	uint32 color = 0xff323232;
//	f_buf_fill板载缓存<uint32>(m_颜色, &color, 1, E_板载缓存类型::e_UBO);
//
//
//	S_着色器创建配置 图元配置 = {
//		{
//			{0, E_着色阶段::e_几何着色, E_板载缓存类型::e_UBO},
//			{1, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},
//			{2, E_着色阶段::e_几何着色, E_板载缓存类型::e_UBO},
//			{3, E_着色阶段::e_像素着色, E_板载缓存类型::e_UBO},
//		},
//		{
//			{0, sizeof(vec4), 0, E_数据格式::e_F_RGBA},
//		},
//		{
//			{S_引擎配置::m_3D着色器文件根路径 + "PBF体素可视预览_顶点阶段.spv", {}, E_着色阶段::e_顶点着色},
//			{S_引擎配置::m_3D着色器文件根路径 + "PBF体素可视预览_几何阶段.spv", {}, E_着色阶段::e_几何着色},
//			{S_引擎配置::m_3D着色器文件根路径 + "PBF体素可视预览_片源阶段.spv", {}, E_着色阶段::e_像素着色},
//		}
//	};
//
//
//	S_线管创建参数 线管参数({ 1024, 1024 });
//	线管参数.m_绘制方式 = E_绘制方式::e_画点集;
//	线管参数.m_填充模式 = E_填充模式::e_填充线;
//	线管参数.m_采样 = ctx.m_采样数;
//	f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
//
//
//	mf_GPU材质槽更新 = f_updateGPU_体素可视网格预览材质参数布局;
//
//}
//
//void S_体素可视网格预览材质::f_域绘制参数(const S_DomProp& 参数) {
//	S_域绘制属性 dim;
//	dim.m_世界大小.x = 参数.m_世界大小.x;
//	dim.m_世界大小.y = 参数.m_世界大小.y;
//	dim.m_世界大小.z = 参数.m_世界大小.z;
//	dim.m_世界大小.w = 参数.m_单元大小;
//
//	dim.m_分辨率 = vec_转uv4(参数.m_分辨率);
//	dim.m_域世界偏移.x = 参数.m_域世界偏移.x;
//	dim.m_域世界偏移.y = 参数.m_域世界偏移.y;
//	dim.m_域世界偏移.z = 参数.m_域世界偏移.z;
//
//	f_buf_set<S_域绘制属性>(m_GPU参数, 0, dim);
//}






S_八叉树可视预览材质::S_八叉树可视预览材质(S_设备环境& ctx) {
	m_GPU参数 = f_buf_create板载缓存(ctx, sizeof(S_DomProp), E_板载缓存类型::e_UBO);
	m_颜色 = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_UBO);

	S_DomProp dim = { {64,64,64}, {10,10,10}, 0.2f };
	f_buf_fill板载缓存<S_DomProp>(m_GPU参数, &dim, 1, E_板载缓存类型::e_UBO);
	uint32 color = 0xff323232;
	f_buf_fill板载缓存<uint32>(m_颜色, &color, 1, E_板载缓存类型::e_UBO);


	S_着色器创建配置 图元配置 = {
		{
			{0, E_着色阶段::e_几何着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},
			{2, E_着色阶段::e_几何着色, E_板载缓存类型::e_UBO},
			{3, E_着色阶段::e_像素着色, E_板载缓存类型::e_UBO},
		},
		{
			{0, sizeof(vec4), 0, E_数据格式::e_F_RGBA},
		},
		{
			{S_引擎配置::m_3D着色器文件根路径 + "PBF体素可视预览_顶点阶段.spv", {}, E_着色阶段::e_顶点着色},
			{S_引擎配置::m_3D着色器文件根路径 + "八叉树可视预览_几何阶段.spv", {}, E_着色阶段::e_几何着色},
			{S_引擎配置::m_3D着色器文件根路径 + "PBF体素可视预览_片源阶段.spv", {}, E_着色阶段::e_像素着色},
		}
	};


	S_线管创建参数 线管参数({ 1024, 1024 });
	线管参数.m_绘制方式 = E_绘制方式::e_画点集;
	线管参数.m_填充模式 = E_填充模式::e_填充线;
	线管参数.m_采样 = ctx.m_采样数;
	f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);


	//mf_GPU材质槽更新 = f_updateGPU_体素可视网格预览材质参数布局;
}

void S_八叉树可视预览材质::f_域绘制参数(const S_DomProp& 参数) {
}



static void f_updateGPU_VecSphere预览材质参数布局(S_材质管线* mat, S_GPU参数布局& layout, uint16 网格属性缓存槽数量) {
	S_VecSphere可视预览材质* sm = (S_VecSphere可视预览材质*)(mat);

	uint16 num = 网格属性缓存槽数量 + 1;
	if (num != layout.m_绑定数量) f_alloc缓存槽(&layout, num);
	layout.m_参数槽[网格属性缓存槽数量] = sm->m_颜色;
}

S_VecSphere可视预览材质::S_VecSphere可视预览材质(S_设备环境& ctx) {
	m_颜色 = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_UBO);

	uint32 color = 0xff3232ff;
	f_buf_fill板载缓存<uint32>(m_颜色, &color, 1, E_板载缓存类型::e_UBO);

	if (m_着色线管 == nullptr) {
		S_着色器创建配置 图元配置 = {
		{
			{0, E_着色阶段::e_几何着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},
			{2, E_着色阶段::e_像素着色, E_板载缓存类型::e_UBO},
		},
		{
			{0, sizeof(vec4), 0, E_数据格式::e_F_RGBA},
		},
		{
			{S_引擎配置::m_3D着色器文件根路径 + "单色VecSphere_顶点阶段.spv", {}, E_着色阶段::e_顶点着色},
			{S_引擎配置::m_3D着色器文件根路径 + "单色VecSphere_几何阶段.spv", {}, E_着色阶段::e_几何着色},
			{S_引擎配置::m_3D着色器文件根路径 + "单色_片源阶段.spv", {}, E_着色阶段::e_像素着色},
		}
		};

		S_线管创建参数 线管参数({ 128, 128 });
		线管参数.m_绘制方式 = E_绘制方式::e_画点集;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
	}
	
	//mf_GPU材质槽更新 = f_updateGPU_VecSphere预览材质参数布局;
}


static void f_updateGPU_Cube预览材质参数布局(S_材质管线* mat, S_GPU参数布局& layout, uint16 网格属性缓存槽数量) {
	S_Cube可视预览材质* sm = (S_Cube可视预览材质*)(mat);

	uint16 num = 网格属性缓存槽数量 + 1;
	if (num != layout.m_绑定数量) f_alloc缓存槽(&layout, num);
	layout.m_参数槽[网格属性缓存槽数量] = sm->m_颜色;
}

S_Cube可视预览材质::S_Cube可视预览材质(S_设备环境& ctx) {
	m_颜色 = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_UBO);

	uint32 color = 0xff3232ff;
	f_buf_fill板载缓存<uint32>(m_颜色, &color, 1, E_板载缓存类型::e_UBO);

	if (m_着色线管 == nullptr) {
		S_着色器创建配置 图元配置 = {
		{
			{0, E_着色阶段::e_几何着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},
			{2, E_着色阶段::e_像素着色, E_板载缓存类型::e_UBO},
		},
		{
			{0, sizeof(vec3), 0, E_数据格式::e_F_RGB},
			{0, sizeof(vec3), 0, E_数据格式::e_F_RGB},
		},
		{
			{S_引擎配置::m_3D着色器文件根路径 + "单色Cube_顶点阶段.spv", {}, E_着色阶段::e_顶点着色},
			{S_引擎配置::m_3D着色器文件根路径 + "单色Cube_几何阶段.spv", {}, E_着色阶段::e_几何着色},
			{S_引擎配置::m_3D着色器文件根路径 + "单色_片源阶段.spv", {}, E_着色阶段::e_像素着色},
		}
		};

		S_线管创建参数 线管参数({ 128, 128 });
		线管参数.m_绘制方式 = E_绘制方式::e_画点集;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
	}

	//mf_GPU材质槽更新 = f_updateGPU_Cube预览材质参数布局;
}



static void f_update单色线描边材质参数布局(S_材质管线* mat, S_GPU参数布局& layout, uint16 网格属性缓存槽数量) {
	S_单色逐顶点线描边材质* sm = (S_单色逐顶点线描边材质*)(mat);

	uint16 num = 网格属性缓存槽数量 + 1;
	if (num != layout.m_绑定数量) f_alloc缓存槽(&layout, num);
	layout.m_参数槽[网格属性缓存槽数量 + 0] = sm->m_Color;
}
S_单色逐顶点线描边材质::S_单色逐顶点线描边材质(S_设备环境& ctx) {
	m_Color = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_UBO);
	f_buf_fill板载缓存<uint32>(m_Color, { f_PackData4X8({200, 100, 64, 255}) }, E_板载缓存类型::e_UBO);

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_画线段;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;

		线管参数.m_启用深度测试 = true;
		线管参数.m_启用写入深度 = true;


		S_着色器创建配置 图元配置 = {
			{
				{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
				{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				{DEF_BINDING_LineProp, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				{3, E_着色阶段::e_像素着色, E_板载缓存类型::e_UBO},
			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(uint32),0,E_数据格式::e_UI_R32},
			},
			{
				{S_引擎配置::m_3D着色器文件根路径 + "逐顶点有色_顶点阶段.spv", {}, E_着色阶段::e_顶点着色},
				{S_引擎配置::m_3D着色器文件根路径 + "逐顶点描边_片源阶段.spv", {}, E_着色阶段::e_像素着色},
			},
			{
				{E_着色阶段::e_顶点着色, 0, sizeof(S_Vert_MeshDrawProp)}
			}
		};

		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
		m_是否以创建着色器 = false;
	}

	//mf_GPU材质槽更新 = f_update单色线描边材质参数布局;
}

void S_单色逐顶点线描边材质::f_set颜色(S_RGBA8UI color, uint32 实例ID) {
	m_Color->f_map();
	((uint32*)(m_Color->m_mappedPtr))[实例ID] = f_PackData4X8(color);
	m_Color->f_unmap();
}






S_物理光照光追材质::S_物理光照光追材质(S_设备环境& ctx) {
	if (!m_是否以创建着色器) {
		S_着色器创建配置 图元配置 = {
			{
				{0, E_着色阶段::e_光追射线生成 | E_着色阶段::e_光追最近相交, E_板载缓存类型::e_光追BVH},
				{1, E_着色阶段::e_顶点着色 | E_着色阶段::e_光追射线生成, E_板载缓存类型::e_IMAGE},
				{2, E_着色阶段::e_光追射线生成 | E_着色阶段::e_光追最近相交 | E_着色阶段::e_光追忽略相交, E_板载缓存类型::e_UBO},
				{3, E_着色阶段::e_光追忽略相交, E_板载缓存类型::e_SSBO},
				{4, E_着色阶段::e_光追忽略相交, E_板载缓存类型::e_SSBO},
			},
			{
			},
			{
				{S_引擎配置::m_3D着色器文件根路径 + "物理光照_光线生成_rgen.spv", {}, E_着色阶段::e_光追射线生成},
				{S_引擎配置::m_3D着色器文件根路径 + "物理光照_最近相交_rchit.spv", {}, E_着色阶段::e_光追最近相交},
				{S_引擎配置::m_3D着色器文件根路径 + "物理光追_光线忽略_rmiss.spv", {}, E_着色阶段::e_光追忽略相交},
			}
		};

		m_着色线管->m_Pipeline = f_df_create光追管线(ctx, nullptr, 图元配置);
	}

}

//void f_material_add线属性(S_材质* material, uint32 num) {
//	S_线逐顶点有色线段材质* 材质 = dynamic_cast<S_线逐顶点有色线段材质*>(material);
//	if (材质) {
//		f_buf_resize(材质->m_绘制参数, 材质->m_绘制参数->m_Size + num);
//	}
//}
//
//void f_material_del线属性(S_材质* material, uint32 ID) {
//	S_线逐顶点有色线段材质* 材质 = dynamic_cast<S_线逐顶点有色线段材质*>(material);
//	if (材质) {
//	}
//}
//
//
//void f_material_set线属性(S_材质* material, uint32 ID, const S_MeshTranformProp& 线属性) {
//	S_线逐顶点有色线段材质* 材质 = dynamic_cast<S_线逐顶点有色线段材质*>(material);
//	if (材质) {
//		S_MeshTranformProp* prop = f_buf_map板载缓存<S_MeshTranformProp>(材质->m_绘制参数);
//		prop[ID] = 线属性;
//		f_buf_unmap板载缓存(材质->m_绘制参数);
//	}
//}






static void f_updateGPU参数配置_数值标注(S_材质管线* mat, S_物体* ob, S_Mesh* mesh, uint8 元素, uint32 多维子元素) {
	S_数值标注材质* sm = (S_数值标注材质*)(mat);
	f_df_allocGPU参数缓存槽(&mesh->m_多维材质槽[多维子元素].m_参数槽, 3);
	//if (mesh->m_GPU参数布局.m_绑定数量 != 3) {
	//	f_alloc缓存槽(&mesh->m_GPU参数布局, 3);
	//	f_alloc纹理槽(&mesh->m_GPU参数布局, 2);
	//}
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[2] = &ob->m_实例颜色[元素];
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[2] = DEF_BINDING_WIDGET_Color;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[2] = E_板载缓存类型::e_SSBO;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[2] = 1;

	mesh->m_多维材质槽[多维子元素].m_参数槽.m_纹理槽 = &sm->纹理槽;
}

static void f_updateGPU参数配置_数值标注线(S_材质管线* mat, S_物体* ob, S_Mesh* mesh, uint8 元素, uint32 多维子元素) {
	S_数值标注材质* sm = (S_数值标注材质*)(mat);
	f_df_allocGPU参数缓存槽(&mesh->m_多维材质槽[多维子元素].m_参数槽, 3);
	//if (mesh->m_GPU参数布局.m_绑定数量 != 3) {
	//	f_alloc缓存槽(&mesh->m_GPU参数布局, 3);
	//}
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[2] = &ob->m_实例颜色[元素];
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[2] = DEF_BINDING_WIDGET_Color;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[2] = E_板载缓存类型::e_SSBO;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[2] = 1;
}


S_数值标注材质::S_数值标注材质(S_设备环境& ctx, bool 线) {
	纹理槽 = f_纹理槽_创建(2);
	f_纹理槽_设置纹理(纹理槽, S_全局缓存::g_默认图标->m_Tex, DEF_BINDING_WIDGET_Texture, 0);
	f_纹理槽_设置纹理(纹理槽, S_全局缓存::g_默认图标->m_Tex, DEF_BINDING_WIDGET_Texture + 1, 1);

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_画点集;
		
		线管参数.m_采样 = ctx.m_采样数;
		
		线管参数.m_深度偏移 = 0.1;


		S_着色器创建配置 图元配置 = {
			{
				{0, E_着色阶段::e_几何着色, E_板载缓存类型::e_UBO},
				{1, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},

				{DEF_BINDING_WIDGET_Color, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},
				//{DEF_BINDING_LineProp, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},

				{DEF_BINDING_WIDGET_Texture, E_着色阶段::e_像素着色, E_板载缓存类型::e_IMAGE_SAMPLER},
				{DEF_BINDING_WIDGET_Texture + 1, E_着色阶段::e_像素着色, E_板载缓存类型::e_IMAGE_SAMPLER},
			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(uint),0,E_数据格式::e_UI_R32},
			},
			{
				{ S_引擎配置::m_3D着色器文件根路径 + "数值标注_顶点阶段.spv", {}, E_着色阶段::e_顶点着色 },
				{ S_引擎配置::m_3D着色器文件根路径 + "数值标注_几何阶段.spv", {}, E_着色阶段::e_几何着色 },
				{ S_引擎配置::m_3D着色器文件根路径 + "数值标注_片源阶段.spv", {}, E_着色阶段::e_像素着色 },
			},
			{
				{ E_着色阶段::e_几何着色, 0, sizeof(S_ShaderConst_TextAttr) },
			}
		};

		if (线) {
			图元配置.m_Paths[1] = { S_引擎配置::m_3D着色器文件根路径 + "数值标注线_几何阶段.spv", {}, E_着色阶段::e_几何着色 };
			图元配置.m_Paths[2] = { S_引擎配置::m_3D着色器文件根路径 + "数值标注线_片源阶段.spv", {}, E_着色阶段::e_像素着色 };

			线管参数.m_填充模式 = E_填充模式::e_填充线;
			mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU参数配置_数值标注线;
		}
		else {
			线管参数.m_填充模式 = E_填充模式::e_填充点;
			mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU参数配置_数值标注;
		}

		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
		 
		m_是否以创建着色器 = false;
	}
	
	++S_全局缓存::m_着色器引用数量;
}

S_数值标注材质::~S_数值标注材质() {
	--S_全局缓存::m_着色器引用数量;

	if (S_全局缓存::m_着色器引用数量 <= 0) {
		f_df_销毁材质着色器(this);
	}
}





static void f_updateGPU参数配置_包围盒(S_材质管线* mat, S_物体* ob, S_Mesh* mesh, uint8 元素, uint32 多维子元素) {
	S_包围盒材质* sm = (S_包围盒材质*)(mat);
	f_df_allocGPU参数缓存槽(&mesh->m_多维材质槽[多维子元素].m_参数槽, 3);
	//if (mesh->m_GPU参数布局.m_绑定数量 != 3) {
	//	f_alloc缓存槽(&mesh->m_GPU参数布局, 3);
	//}
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[2] = &ob->m_实例颜色[元素];
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[2] = DEF_BINDING_WIDGET_Color;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[2] = E_板载缓存类型::e_SSBO;
	mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[2] = 1;
}

S_包围盒材质::S_包围盒材质(S_设备环境& ctx, bool 线) {
	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_画点集;

		线管参数.m_采样 = ctx.m_采样数;

		线管参数.m_深度偏移 = 0.1;


		S_着色器创建配置 图元配置 = {
			{
				{0, E_着色阶段::e_几何着色, E_板载缓存类型::e_UBO},
				{1, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},

				{DEF_BINDING_WIDGET_Color, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},
				//{DEF_BINDING_LineProp, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},

			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(vec2),0,E_数据格式::e_F_R32G32},
			},
			{
				{ S_引擎配置::m_3D着色器文件根路径 + "单色Cube_顶点阶段.spv", {}, E_着色阶段::e_顶点着色 },
				{ S_引擎配置::m_3D着色器文件根路径 + "单色Cube_几何阶段.spv", {}, E_着色阶段::e_几何着色 },
				{ S_引擎配置::m_3D着色器文件根路径 + "单色Cube_片源阶段.spv", {}, E_着色阶段::e_像素着色 },
			},
			{
				{ E_着色阶段::e_顶点着色, 0, sizeof(S_Vert_MeshDrawProp) },
			}
		};

		mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU参数配置_包围盒;


		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
		m_是否以创建着色器 = false;
	}
	++S_全局缓存::m_着色器引用数量;
}

S_包围盒材质::~S_包围盒材质() {
	--S_全局缓存::m_着色器引用数量;

	if (S_全局缓存::m_着色器引用数量 <= 0) {
		f_df_销毁材质着色器(this);
	}
}






static void f_updateGPU参数配置_AABB(S_材质管线* mat, S_物体* ob, S_Mesh* me, uint8 元素, uint32 多维子元素) {
	S_AABB材质* sm = (S_AABB材质*)(mat);
	f_df_allocGPU参数缓存槽(&(me->m_多维材质槽[多维子元素].m_参数槽), 4);
	
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[2] = &ob->m_实例颜色[元素];
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[2] = DEF_BINDING_WIDGET_Color;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[2] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[2] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[3] = &me->m_网格元素变换属性;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[3] = DEF_BINDING_LineProp;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[3] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[3] = 1;
}

S_AABB材质::S_AABB材质(S_设备环境& ctx) {
	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_画点集;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;

		线管参数.m_深度偏移 = 0.1;


		S_着色器创建配置 图元配置 = {
			{
				{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
				{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},

				{DEF_BINDING_WIDGET_Color, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				{DEF_BINDING_LineProp, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
			},
			{
				{ S_引擎配置::m_3D着色器文件根路径 + "AABB.vspv", {}, E_着色阶段::e_顶点着色 },
				{ S_引擎配置::m_3D着色器文件根路径 + "AABB.gspv", {}, E_着色阶段::e_几何着色 },
				{ S_引擎配置::m_3D着色器文件根路径 + "AABB.fspv", {}, E_着色阶段::e_像素着色 },
			},
			{
				{ E_着色阶段::e_顶点着色, 0, sizeof(S_Vert_MeshDrawProp) },
			}
		};

		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
		m_是否以创建着色器 = false;
	}
	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU参数配置_AABB;
	++S_全局缓存::m_着色器引用数量;
}

S_AABB材质::~S_AABB材质() {
	--S_全局缓存::m_着色器引用数量;

	if (S_全局缓存::m_着色器引用数量 <= 0) {
		f_df_销毁材质着色器(this);
	}
}



/*S_权重可视线材质::S_权重可视线材质(S_设备环境& ctx) {
	m_Color = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_UBO);
	f_buf_fill板载缓存<uint32>(m_Color, { f_PackData4X8({25, 25, 28, 255}) }, E_板载缓存类型::e_UBO);

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_三角形;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;


		S_着色器创建配置 图元配置 = f_权重可视图元配置();
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = false;
		f_创建骨骼GPU默认参数(ctx);
	}

	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU权重可视参数配置;
}*/

/*static void f_updateGPU单色描边材质参数布局(S_材质* mat, S_GPU参数布局& layout, uint16 网格属性缓存槽数量) {
	S_基本光照描边材质* sm = (S_基本光照描边材质*)(mat);

	uint16 num = 网格属性缓存槽数量 + 1;
	if (num != sm->m_参数数量) f_alloc缓存槽(&layout, num);
	layout.m_参数槽[网格属性缓存槽数量 + 0] = sm->m_Color;
}*/

//static void f_updateGPU基本光照参数布局(S_材质* mat, S_GPU参数布局& layout, uint16 网格属性缓存槽数量) {
//	S_基本光照描边材质* sm = (S_基本光照描边材质*)(mat);
//
//	uint16 num = 网格属性缓存槽数量 + 2;
//	if (num != layout.m_参数数量) {
//		f_alloc缓存槽(&layout, num);
//		//if (纹理槽数量) f_alloc缓存槽(&layout, 纹理槽数量);
//		layout.m_参数槽[2] = sm->m_灯光方向;
//		layout.m_绑定位置[2] = 2;
//		layout.m_参数槽[3] = S_物体::g_物体颜色;
//		layout.m_绑定位置[3] = DEF_BINDING_WIDGET_Color;
//	}
//}

/*static S_着色器创建配置 f_描边图元配置() {
	S_着色器创建配置 图元配置;

	图元配置 = {
		{
			{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},

			{2, E_着色阶段::e_像素着色, E_板载缓存类型::e_UBO},
		},
		{
			{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
			{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
		},
		{
			{"D:/U/Project/engine/材质/着色/compiled/描边_顶点阶段.spv", E_着色阶段::e_顶点着色},
			{"D:/U/Project/engine/材质/着色/compiled/描边_片源阶段.spv", E_着色阶段::e_像素着色},
		}
	};

	return 图元配置;
}*/

//static void f_updateGPU基本光照参数配置_面(S_材质* mat, S_物体* ob, S_Mesh* mesh, uint8 槽) {
//	S_面基本光照材质* sm = (S_面基本光照材质*)(mat);
//
//	if (mesh->m_GPU参数布局.m_参数数量 != 8) {
//		f_alloc缓存槽(&mesh->m_GPU参数布局, 8);
//
//		mesh->m_GPU参数布局.m_参数槽[2] = sm->m_灯光方向;
//		mesh->m_GPU参数布局.m_绑定位置[2] = 2;
//		mesh->m_GPU参数布局.m_参数槽[3] = S_物体::g_物体颜色[槽];
//		mesh->m_GPU参数布局.m_绑定位置[3] = DEF_BINDING_WIDGET_Color;
//	}
//	mesh->m_GPU参数布局.m_参数槽[7] = mesh->m_网格属性.m_Buf;
//	mesh->m_GPU参数布局.m_绑定位置[7] = DEF_BINDING_LineProp;
//
//	f_updateGPU基本光照参数配置(ob, mesh);
//}
//
//
//static void f_updateGPU基本光照参数配置_线(S_材质* mat, S_物体* ob, S_Mesh* mesh, uint8 槽) {
//	S_线基本光照材质* sm = (S_线基本光照材质*)(mat);
//
//	if (mesh->m_GPU参数布局.m_参数数量 != 8) {
//		f_alloc缓存槽(&mesh->m_GPU参数布局, 8);
//
//		mesh->m_GPU参数布局.m_参数槽[2] = sm->m_灯光方向;
//		mesh->m_GPU参数布局.m_绑定位置[2] = 2;
//		mesh->m_GPU参数布局.m_参数槽[3] = S_物体::g_物体颜色[槽];
//		mesh->m_GPU参数布局.m_绑定位置[3] = DEF_BINDING_WIDGET_Color;
//	}
//	mesh->m_GPU参数布局.m_参数槽[7] = mesh->m_网格属性.m_Buf;
//	mesh->m_GPU参数布局.m_绑定位置[7] = DEF_BINDING_LineProp;
//
//	f_updateGPU基本光照参数配置(ob, mesh);
//}


//static S_线管创建配置 f_权重可视图元配置() {
//	S_线管创建配置 图元配置;
//
//	图元配置 = {
//		{
//			{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
//			{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
//			{DEF_BINDING_Bones_Focus, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},	//骨骼选中
//			{DEF_BINDING_Bones_Props, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},	//骨骼属性
//			{DEF_BINDING_Bones_Weigth, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},	//顶点指向骨骼ID权重
//			//{DEF_BINDING_Bones_Matrix, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},	//骨骼变换矩阵
//		},
//		{
//			{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
//			{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
//			{0,sizeof(vec2),0,E_数据格式::e_F_R32G32},
//		},
//		{
//			{S_引擎配置::m_3D着色器文件根路径 + "权重_顶点阶段.spv", E_着色阶段::e_顶点着色},
//			{S_引擎配置::m_3D着色器文件根路径 + "权重_片源阶段.spv", E_着色阶段::e_像素着色},
//		},
//		{
//			{E_着色阶段::e_顶点着色, 0, sizeof(S_Vert_MeshDrawProp)},
//		}
//	};
//
//	return 图元配置;
//}

S_天空盒材质::S_天空盒材质(S_设备环境& ctx) {
	
}

S_天空盒材质::~S_天空盒材质() {
}










//void f_update着色器_骨骼配置(S_物体* ob, S_Mesh* mesh)
//{
//	if (ob->m_骨架) {
//		mesh->m_GPU参数布局.m_参数槽[4] = mesh->m_顶点骨骼属性->m_Buf;
//		mesh->m_GPU参数布局.m_绑定位置[4] = DEF_BINDING_Bones_Props;
//
//		mesh->m_GPU参数布局.m_参数槽[5] = mesh->m_骨骼权重映射->m_Buf;
//		mesh->m_GPU参数布局.m_绑定位置[5] = DEF_BINDING_Bones_Map;
//
//		mesh->m_GPU参数布局.m_参数槽[6] = ob->m_骨架->m_姿态.m_Buf;
//		mesh->m_GPU参数布局.m_绑定位置[6] = DEF_BINDING_Bones_Matrix;
//
//	}
//	else {
//		mesh->m_GPU参数布局.m_参数槽[4] = g_骨骼默认缓存_骨骼索引;
//		mesh->m_GPU参数布局.m_绑定位置[4] = DEF_BINDING_Bones_Props;
//
//		mesh->m_GPU参数布局.m_参数槽[5] = g_骨骼默认缓存_顶点权重;
//		mesh->m_GPU参数布局.m_绑定位置[5] = DEF_BINDING_Bones_Map;
//
//		mesh->m_GPU参数布局.m_参数槽[6] = g_骨骼默认缓存_骨骼变换;
//		mesh->m_GPU参数布局.m_绑定位置[6] = DEF_BINDING_Bones_Matrix;
//	}
//}



//void f_updateGPU基本光照参数_骨骼配置(S_物体* ob, S_Mesh* mesh, uint32 多维子元素, uint32 offset) {
//	//if (纹理槽数量) f_alloc缓存槽(&layout, 纹理槽数量);
//	if (ob->m_骨架) {
//		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[offset] = mesh->m_顶点骨骼属性;
//		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[offset] = DEF_BINDING_Bones_Props;
//		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[offset] = E_板载缓存类型::e_SSBO;
//		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[offset] = 1;
//
//		++offset;
//		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[offset] = mesh->m_骨骼权重映射;
//		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[offset] = DEF_BINDING_Bones_Map;
//		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[offset] = E_板载缓存类型::e_SSBO;
//		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[offset] = 1;
//
//		++offset;
//		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[offset] = &ob->m_骨架->m_姿态;
//		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[offset] = DEF_BINDING_Bones_Matrix;
//		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[offset] = E_板载缓存类型::e_SSBO;
//		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[offset] = 1;
//	}
//	else {
//		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[offset] = g_骨骼默认缓存_顶点骨骼;
//		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[offset] = DEF_BINDING_Bones_Props;
//		
//		++offset;
//		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[offset] = g_骨骼默认缓存_顶点权重;
//		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[offset] = DEF_BINDING_Bones_Map;
//
//		++offset;
//		mesh->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[offset] = g_骨骼默认缓存_骨骼变换;
//		mesh->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[offset] = DEF_BINDING_Bones_Matrix;
//	}
//}



//static void f_updateGPU独立缩放单色着色参数配置(S_材质* mat, S_物体* ob, S_Mesh* mesh) {
//	S_单色材质* sm = (S_单色材质*)(mat);
//
//	if (mesh->m_GPU参数布局.m_绑定数量 != 5) {
//		f_alloc缓存槽(&mesh->m_GPU参数布局, 5);
//
//		mesh->m_GPU参数布局.m_绑定位置[0] = 0;
//		mesh->m_GPU参数布局.m_绑定位置[1] = 1;
//
//		mesh->m_GPU参数布局.m_参数槽[2] = mesh->m_颜色->m_Buf;
//		mesh->m_GPU参数布局.m_绑定位置[2] = 2;
//
//		mesh->m_GPU参数布局.m_参数槽[3] = sm->m_Color;
//		mesh->m_GPU参数布局.m_绑定位置[3] = 3;
//
//		mesh->m_GPU参数布局.m_参数槽[4] = sm->m_材质属性;
//		mesh->m_GPU参数布局.m_绑定位置[4] = 4;
//	}
//
//	if (ob->m_骨架) {
//		//mesh->m_GPU参数布局.m_参数槽[3] = ob->m_骨架->m_骨骼长度.m_Buf;
//		mesh->m_GPU参数布局.m_参数槽[4] = ob->m_独立缩放;
//		f_buf_fill板载缓存<S_单色材质属性>(ob->m_独立缩放, { {1, mesh->m_深度控制.x, mesh->m_深度控制.y, 0} }, E_板载缓存类型::e_UBO);
//	}
//	else {
//		mesh->m_GPU参数布局.m_参数槽[3] = sm->m_Color;
//		f_buf_fill板载缓存<S_单色材质属性>(sm->m_材质属性, { {0, mesh->m_深度控制.x, mesh->m_深度控制.y, 0} }, E_板载缓存类型::e_UBO);
//	}
//}


//static void f_updateGPU单色着色参数配置(S_材质* mat, S_物体* ob, S_Mesh* mesh) {
//	S_单色材质* sm = (S_单色材质*)(mat);
//
//	if (mesh->m_GPU参数布局.m_绑定数量 != 3) {
//		f_alloc缓存槽(&mesh->m_GPU参数布局, 3);
//
//		mesh->m_GPU参数布局.m_绑定位置[0] = 0;
//		mesh->m_GPU参数布局.m_绑定位置[1] = 1;
//
//		mesh->m_GPU参数布局.m_参数槽[2] = mesh->m_颜色->m_Buf;
//		mesh->m_GPU参数布局.m_绑定位置[2] = 2;
//	}
//}


static void f_updatePBR材质参数配置(S_材质管线* mat, S_物体* ob, S_Mesh* me, uint8 元素, uint32 多维子元素) {
	f_df_allocGPU参数缓存槽(&me->m_多维材质槽[多维子元素].m_参数槽, 3);

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[1] = &ob->m_实例颜色[元素];
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[1] = DEF_BINDING_WIDGET_Color;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[1] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[1] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[2] = &me->m_网格元素变换属性;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[2] = DEF_BINDING_LineProp;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[2] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[2] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_纹理槽 = &((S_PBR材质*)mat)->m_纹理槽;

	me->m_多维材质槽[多维子元素].m_参数槽.m_GPU布局描述 = S_PBR材质::g_参数布局;
}


S_PBR材质::S_PBR材质(S_设备环境& ctx) {
	m_独立统一缓存 = true;
	m_纹理槽 = f_纹理槽_创建(1);
	m_纹理集 = f_纹理集_创建();

	f_纹理集_add纹理(m_纹理集, S_全局缓存::g_空纹理);
	f_纹理槽_设置纹理集(m_纹理槽, m_纹理集, 0, DEF_BINDING_WIDGET_Texture);

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });

		线管参数.m_填充模式 = E_填充模式::e_填充面;
		线管参数.m_绘制方式 = E_绘制方式::e_三角形;
		线管参数.m_采样 = ctx.m_采样数;


		S_着色器创建配置 图元配置 = {
			{
			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(vec2),0,E_数据格式::e_F_R32G32},
			},

			{
				{ S_引擎配置::m_3D着色器文件根路径 + "PBR.vspv", {}, E_着色阶段::e_顶点着色 },
				{ S_引擎配置::m_3D着色器文件根路径 + "PBR.fspv", {}, E_着色阶段::e_像素着色 },
			},

			{
				{ E_着色阶段::e_顶点着色, 0, sizeof(S_Vert_MeshDrawProp) },
			}
		};

		std::vector<S_着色器创建参数> 参数布局;
		参数布局 = {
			{1,										E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_LineProp,					E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_WIDGET_Color,				E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_WIDGET_Texture,			E_着色阶段::e_像素着色, E_板载缓存类型::e_IMAGE_SAMPLER},
		};
		//g_参数布局 = f_df_创建着色器参数布局(ctx, 参数布局, nullptr);


		//S_结构对象* layout[3] = { S_Engine::g_摄像机GPU布局描述, g_参数布局, S_Engine::g_光栅最终渲染参数布局 };
		//图元配置.m_Paths[1] = { S_引擎配置::m_3D着色器文件根路径 + "PBR.fspv", {}, E_着色阶段::e_像素着色 };
		//线管参数.m_槽 = E_管线槽::e_颜色渲染;
		//g管线引用.m_着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 3, E_管线槽::e_颜色渲染);
		//
		//
		//layout[2] = S_Engine::g_场景几何纹理渲染布局;
		//图元配置.m_Paths[1] = { S_引擎配置::m_3D着色器文件根路径 + "PBR_GBuffer.fspv", {}, E_着色阶段::e_像素着色 };
		//线管参数.m_槽 = E_管线槽::e_几何渲染;
		//g管线引用.m_几何着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 3, E_管线槽::e_几何渲染);
		//
		//
		//layout[2] = S_Engine::g_场景环境渲染参数布局;
		//图元配置.m_Paths[1] = { S_引擎配置::m_3D着色器文件根路径 + "PBR_Env.fspv", {}, E_着色阶段::e_像素着色 };
		//线管参数.m_槽 = E_管线槽::e_环境渲染;
		//g管线引用.m_环境着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 3, E_管线槽::e_环境渲染);
		//
		//
		//图元配置.m_Paths[1] = { S_引擎配置::m_3D着色器文件根路径 + "PBR_Shadow.fspv", {}, E_着色阶段::e_像素着色 };
		//线管参数.m_槽 = E_管线槽::e_阴影渲染;
		//g管线引用.m_阴影着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 2, E_管线槽::e_阴影渲染);

		
		m_是否以创建着色器 = true;
	}
	else {
		f_pl_引用管线(this, g管线引用);
	}

	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updatePBR材质参数配置;
	
}

S_PBR材质::~S_PBR材质() {
	
}





static void f_updatePBR阴影材质参数配置(S_材质管线* mat, S_物体* ob, S_Mesh* me, uint8 元素, uint32 多维子元素) {
	f_df_allocGPU参数缓存槽(&me->m_多维材质槽[多维子元素].m_参数槽, 4);

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[1] = &ob->m_实例颜色[元素];
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[1] = DEF_BINDING_WIDGET_Color;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[1] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[1] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[2] = &me->m_网格元素变换属性;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[2] = DEF_BINDING_LineProp;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[2] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[2] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_纹理槽;
}

S_PBR阴影材质::S_PBR阴影材质(S_设备环境& ctx) {
	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });

		线管参数.m_填充模式 = E_填充模式::e_填充点;
		线管参数.m_绘制方式 = E_绘制方式::e_画点集;
		线管参数.m_采样 = ctx.m_采样数;


		S_着色器创建配置 图元配置 = {
			{
				{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
				{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				{DEF_BINDING_WIDGET_Color, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				{DEF_BINDING_LineProp, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(uvec2),0,E_数据格式::e_UI_R32G32},
			},

			{
				{ S_引擎配置::m_3D着色器文件根路径 + "PBR.vspv", {}, E_着色阶段::e_顶点着色 },
				{ S_引擎配置::m_3D着色器文件根路径 + "PBR_Shadow.fspv", {}, E_着色阶段::e_像素着色 },
			},

			{
				{ E_着色阶段::e_顶点着色, 0, sizeof(S_Vert_MeshDrawProp) },
			}
		};

		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
		m_是否以创建着色器 = false;


	}

	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_update基本光照点材质参数配置;
	
}

S_PBR阴影材质::~S_PBR阴影材质() {
	
}




static void f_update天空材质参数配置(S_材质管线* mat, S_物体* ob, S_Mesh* me, uint8 元素, uint32 多维子元素) {
	f_df_allocGPU参数缓存槽(&me->m_多维材质槽[多维子元素].m_参数槽, 3);

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[1] = &ob->m_实例颜色[元素];
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[1] = DEF_BINDING_WIDGET_Color;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[1] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[1] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[2] = &me->m_网格元素变换属性;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[2] = DEF_BINDING_LineProp;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[2] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[2] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_纹理槽 = &((S_天空材质*)mat)->m_纹理槽;

	me->m_多维材质槽[多维子元素].m_参数槽.m_GPU布局描述 = S_天空材质::g_参数布局;
}

S_天空材质::S_天空材质(S_设备环境& ctx) {
	m_独立统一缓存 = true;
	m_纹理槽 = f_纹理槽_创建(1);
	m_纹理集 = f_纹理集_创建();

	f_纹理集_add纹理(m_纹理集, S_全局缓存::g_空纹理);
	f_纹理槽_设置纹理集(m_纹理槽, m_纹理集, 0, DEF_BINDING_WIDGET_Texture);

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });

		线管参数.m_填充模式 = E_填充模式::e_填充面;
		线管参数.m_绘制方式 = E_绘制方式::e_三角形;
		线管参数.m_采样 = ctx.m_采样数;


		S_着色器创建配置 图元配置 = {
			{
			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(vec2),0,E_数据格式::e_F_R32G32},
			},

			{
				{ S_引擎配置::m_3D着色器文件根路径 + "PBR.vspv", {}, E_着色阶段::e_顶点着色 },
				{ S_引擎配置::m_3D着色器文件根路径 + "Sky.fspv", {}, E_着色阶段::e_像素着色 },
			},

			{
				{ E_着色阶段::e_顶点着色, 0, sizeof(S_Vert_MeshDrawProp) },
			}
		};

		std::vector<S_着色器创建参数> 参数布局;
		参数布局 = {
			{1,										E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_LineProp,					E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_WIDGET_Color,				E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_WIDGET_Texture,			E_着色阶段::e_像素着色, E_板载缓存类型::e_IMAGE_SAMPLER},

			//{DEF_BINDING_TasterBindID_MaterialID,	E_着色阶段::e_像素着色, E_板载缓存类型::e_SSBO},
		};
		//g_参数布局 = f_df_创建着色器参数布局(ctx, 参数布局, nullptr);
		//S_结构对象* layout[3] = { S_Engine::g_摄像机GPU布局描述, g_参数布局, S_Engine::g_场景环境渲染参数布局 };
		//
		//线管参数.m_槽 = E_管线槽::e_颜色渲染;
		//g管线引用.m_着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 3, E_管线槽::e_颜色渲染);
		//
		//线管参数.m_槽 = E_管线槽::e_环境渲染;
		//g管线引用.m_环境着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 3, E_管线槽::e_环境渲染);
		//
		//线管参数.m_槽 = E_管线槽::e_阴影渲染;
		//g管线引用.m_阴影着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 3, E_管线槽::e_阴影渲染);
		//
		//线管参数.m_槽 = E_管线槽::e_几何渲染;
		//g管线引用.m_几何着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 3, E_管线槽::e_几何渲染);

		m_是否以创建着色器 = false;
	}
	else {
		f_pl_引用管线(this, g管线引用);
	}

	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_update天空材质参数配置;

}

S_天空材质::~S_天空材质() {

}






static void f_updatePBR线段材质参数配置(S_材质管线* mat, S_物体* ob, S_Mesh* me, uint8 元素, uint32 多维子元素) {
	f_df_allocGPU参数缓存槽(&me->m_多维材质槽[多维子元素].m_参数槽, 3);

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[1] = &ob->m_实例颜色[元素];
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[1] = DEF_BINDING_WIDGET_Color;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[1] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[1] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[2] = &me->m_网格元素变换属性;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[2] = DEF_BINDING_LineProp;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[2] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[2] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_纹理槽 = &((S_PBR线段材质*)mat)->m_纹理槽;

	me->m_多维材质槽[多维子元素].m_参数槽.m_GPU布局描述 = S_PBR线段材质::g_参数布局;
}

S_PBR线段材质::S_PBR线段材质(S_设备环境& ctx) {
	m_独立统一缓存 = true;
	m_纹理槽 = f_纹理槽_创建(1);
	m_纹理集 = f_纹理集_创建();

	f_纹理集_add纹理(m_纹理集, S_全局缓存::g_空纹理);
	f_纹理槽_设置纹理集(m_纹理槽, m_纹理集, 0, DEF_BINDING_WIDGET_Texture);

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });

		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_绘制方式 = E_绘制方式::e_画线段;
		线管参数.m_采样 = ctx.m_采样数;


		S_着色器创建配置 图元配置 = {
			{
			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(vec2),0,E_数据格式::e_F_R32G32},
			},

			{
				{ S_引擎配置::m_3D着色器文件根路径 + "PBR_Line.vspv", {}, E_着色阶段::e_顶点着色 },
				{ S_引擎配置::m_3D着色器文件根路径 + "PBR_Line.gspv", {}, E_着色阶段::e_几何着色 },
				{ S_引擎配置::m_3D着色器文件根路径 + "PBR_Line.fspv", {}, E_着色阶段::e_像素着色 },
			},

			{
				{ E_着色阶段::e_顶点着色, 0, sizeof(S_Vert_MeshDrawProp) },
			}
		};

		std::vector<S_着色器创建参数> 参数布局;
		参数布局 = {
			{1,										E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_LineProp,					E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_WIDGET_Color,				E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_WIDGET_Texture,			E_着色阶段::e_像素着色, E_板载缓存类型::e_IMAGE_SAMPLER},

			//{DEF_BINDING_TasterBindID_MaterialID,	E_着色阶段::e_像素着色, E_板载缓存类型::e_SSBO},
		};
		//g_参数布局 = f_df_创建着色器参数布局(ctx, 参数布局, nullptr);
		//S_结构对象* layout[3] = { S_Engine::g_摄像机GPU布局描述, g_参数布局, S_Engine::g_光栅最终渲染参数布局 };
		//
		//线管参数.m_槽 = E_管线槽::e_颜色渲染;
		//g管线引用.m_着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 3, E_管线槽::e_颜色渲染);
		//
		//layout[2] = S_Engine::g_场景环境渲染参数布局;
		//图元配置.m_Paths[2] = { S_引擎配置::m_3D着色器文件根路径 + "PBR_Env.fspv", {}, E_着色阶段::e_像素着色 };
		//线管参数.m_槽 = E_管线槽::e_环境渲染;
		//g管线引用.m_环境着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 3, E_管线槽::e_环境渲染);
		//
		//layout[2] = S_Engine::g_场景几何纹理渲染布局;
		//图元配置.m_Paths[2] = { S_引擎配置::m_3D着色器文件根路径 + "PBR_GBuffer.fspv", {}, E_着色阶段::e_像素着色 };
		//线管参数.m_槽 = E_管线槽::e_几何渲染;
		//g管线引用.m_几何着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 3, E_管线槽::e_几何渲染);
		//
		//图元配置.m_Paths[2] = { S_引擎配置::m_3D着色器文件根路径 + "PBR_Shadow.fspv", {}, E_着色阶段::e_像素着色 };
		//线管参数.m_槽 = E_管线槽::e_阴影渲染;
		//g管线引用.m_阴影着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 2, E_管线槽::e_阴影渲染);

		m_是否以创建着色器 = true;
	}
	else {
		f_pl_引用管线(this, g管线引用);
	}

	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updatePBR线段材质参数配置;

}

S_PBR线段材质::~S_PBR线段材质() {
	f_纹理槽_销毁(m_纹理槽);
	f_纹理集_销毁(m_纹理集);
}





static void f_update线段材质参数配置(S_材质管线* mat, S_物体* ob, S_Mesh* me, uint8 元素, uint32 多维子元素) {
	f_df_allocGPU参数缓存槽(&me->m_多维材质槽[多维子元素].m_参数槽, 2);

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[1] = &ob->m_实例颜色[元素];
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[1] = DEF_BINDING_WIDGET_Color;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[1] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[1] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_纹理槽 = &((S_线段材质*)mat)->m_纹理槽;

	me->m_多维材质槽[多维子元素].m_参数槽.m_GPU布局描述 = S_线段材质::g_参数布局;
}

S_线段材质::S_线段材质(S_设备环境& ctx) {
	m_独立统一缓存 = true;
	//m_纹理槽 = f_tex_创建纹理槽(1);
	//m_纹理集 = f_纹理集_创建();

	//f_纹理集_add纹理(m_纹理集, S_全局缓存::g_空纹理);
	//f_纹理槽_设置纹理集(m_纹理槽, m_纹理集, 0, DEF_BINDING_WIDGET_Texture);

	if (!g_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });

		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_绘制方式 = E_绘制方式::e_画线段;
		线管参数.m_采样 = ctx.m_采样数;


		S_着色器创建配置 图元配置 = {
			{
			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(uint32),0,E_数据格式::e_UI_R32},
			},

			{
				{ S_引擎配置::m_3D着色器文件根路径 + "Line.vspv", {}, E_着色阶段::e_顶点着色 },
				{ S_引擎配置::m_3D着色器文件根路径 + "Line.fspv", {}, E_着色阶段::e_像素着色 },
			},

			{
				{ E_着色阶段::e_顶点着色, 0, sizeof(S_Vert_MeshDrawProp) },
			}
		};

		std::vector<S_着色器创建参数> 参数布局;
		参数布局 = {
			{1,										E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_LineProp,					E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_WIDGET_Color,				E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_WIDGET_Texture,			E_着色阶段::e_像素着色, E_板载缓存类型::e_IMAGE_SAMPLER},

			//{DEF_BINDING_TasterBindID_MaterialID,	E_着色阶段::e_像素着色, E_板载缓存类型::e_SSBO},
		};
		//g_参数布局 = f_df_创建着色器参数布局(ctx, 参数布局, nullptr);
		//S_结构对象* layout[3] = { S_Engine::g_摄像机GPU布局描述, g_参数布局, S_Engine::g_光栅最终渲染参数布局 };
		//
		//线管参数.m_槽 = E_管线槽::e_颜色渲染;
		//g_管线引用.m_着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 2, E_管线槽::e_颜色渲染);

		//layout[2] = S_Engine::g_场景环境渲染参数布局;
		//图元配置.m_Paths[2] = { S_引擎配置::m_3D着色器文件根路径 + "PBR_Env.fspv", {}, E_着色阶段::e_像素着色 };
		//线管参数.m_槽 = E_管线槽::e_环境渲染;
		//g管线引用.m_环境着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 3, E_管线槽::e_环境渲染);
		//
		//layout[2] = S_Engine::g_场景几何纹理渲染布局;
		//图元配置.m_Paths[2] = { S_引擎配置::m_3D着色器文件根路径 + "PBR_GBuffer.fspv", {}, E_着色阶段::e_像素着色 };
		//线管参数.m_槽 = E_管线槽::e_几何渲染;
		//g管线引用.m_几何着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 3, E_管线槽::e_几何渲染);
		//
		//图元配置.m_Paths[2] = { S_引擎配置::m_3D着色器文件根路径 + "PBR_Shadow.fspv", {}, E_着色阶段::e_像素着色 };
		//线管参数.m_槽 = E_管线槽::e_阴影渲染;
		//g管线引用.m_阴影着色线管 = f_df_创建材质着色器(ctx, this, 图元配置, 线管参数, layout, 2, E_管线槽::e_阴影渲染);

		g_是否以创建着色器 = true;
	}
	else {
		f_pl_引用管线(this, g_管线引用);
	}

	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_update线段材质参数配置;

}

S_线段材质::~S_线段材质() {
	//f_tex_销毁纹理槽(m_纹理槽);
	//f_纹理集_销毁(m_纹理集);
}
